home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 001 / pibt32s2.arc / PIBDIALA.PAS < prev    next >
Encoding:
Pascal/Delphi Source File  |  1985-12-01  |  56.7 KB  |  1,534 lines
  1. (*----------------------------------------------------------------------*)
  2. (*                PibDialer --- Dialing Management                      *)
  3. (*----------------------------------------------------------------------*)
  4.  
  5. OVERLAY PROCEDURE PibDialer( ReDial         : BOOLEAN;
  6.                              Dialing_String : AnyStr );
  7.  
  8. (*----------------------------------------------------------------------*)
  9. (*                                                                      *)
  10. (*     Procedure:  PibDialer                                            *)
  11. (*                                                                      *)
  12. (*     Purpose:    Main routine for dials/redials                       *)
  13. (*                                                                      *)
  14. (*     Calling Sequence:                                                *)
  15. (*                                                                      *)
  16. (*        PibDialer( ReDial         : BOOLEAN;                          *)
  17. (*                   Dialing_String : AnyStr );                         *)
  18. (*                                                                      *)
  19. (*           ReDial --- TRUE for redial, FALSE for ordinary dial        *)
  20. (*           Dialing_String --- if not null, use this as number to      *)
  21. (*                              be dialed.                              *)
  22. (*                                                                      *)
  23. (*     Calls:                                                           *)
  24. (*                                                                      *)
  25. (*           Dial_A_Number                                              *)
  26. (*           Redial_A_Number                                            *)
  27. (*                                                                      *)
  28. (*    Remarks:                                                          *)
  29. (*                                                                      *)
  30. (*        This routine exists solely to route calls to Dial_A_Number    *)
  31. (*        and Redial_A-Number.  This setup is used so that the Turbo    *)
  32. (*        Pascal overlay scheme will work correctly.                    *)
  33. (*                                                                      *)
  34. (*----------------------------------------------------------------------*)
  35.  
  36. CONST
  37.    Max_Dial_Nos = 10;
  38.  
  39. VAR
  40.    Local_Save_4   : Saved_Screen_Ptr;
  41.    Session_Active : BOOLEAN;
  42.    Xpos1          : INTEGER;
  43.    Manual_Dial    : BOOLEAN;
  44.    Quit           : BOOLEAN;
  45.    N_Dial_Nos     : INTEGER;
  46.    Dial_Nos       : ARRAY[1..Max_Dial_Nos] OF STRING[64];
  47.  
  48. (*----------------------------------------------------------------------*)
  49. (*          Dialer_Carrier_Detect --- Look for carrier detect           *)
  50. (*----------------------------------------------------------------------*)
  51.  
  52. FUNCTION Dialer_Carrier_Detect : BOOLEAN;
  53.  
  54. (*----------------------------------------------------------------------*)
  55. (*                                                                      *)
  56. (*     Function:  Dialer_Carrier_Detect                                 *)
  57. (*                                                                      *)
  58. (*     Purpose:   Looks for a carrier detect                            *)
  59. (*                                                                      *)
  60. (*     Calling Sequence:                                                *)
  61. (*                                                                      *)
  62. (*        Carrier := Dialer_Carrier_Detect;                             *)
  63. (*                                                                      *)
  64. (*           Carrier  --- TRUE if carrier detect found                  *)
  65. (*                                                                      *)
  66. (*     Calls:                                                           *)
  67. (*                                                                      *)
  68. (*        Async_Carrier_Detect;                                         *)
  69. (*                                                                      *)
  70. (*     Remarks:                                                         *)
  71. (*                                                                      *)
  72. (*        This routine is essentially a filter for Async_Carrier_Detect *)
  73. (*        except that if the global flag Modem_Carrier_High is set, it  *)
  74. (*        returns FALSE.  This is to support modems which always keep   *)
  75. (*        the carrier detect line high.                                 *)
  76. (*                                                                      *)
  77. (*----------------------------------------------------------------------*)
  78.  
  79. BEGIN (* Dialer_Carrier_Detect *)
  80.  
  81.    IF Modem_Carrier_High THEN
  82.       Dialer_Carrier_Detect := FALSE
  83.    ELSE
  84.       Dialer_Carrier_Detect := Async_Carrier_Detect;
  85.  
  86. END   (* Dialer_Carrier_Detect *);
  87.  
  88. (*----------------------------------------------------------------------*)
  89. (*          Read_Number_Or_ESC --- Read in number or get escape         *)
  90. (*----------------------------------------------------------------------*)
  91.  
  92. PROCEDURE Read_Number_Or_ESC(     Ch        : CHAR;
  93.                                   Xpos      : INTEGER;
  94.                               VAR SNumber   : AnyStr;
  95.                               VAR Pre_Str   : AnyStr;
  96.                               VAR Post_Str  : AnyStr;
  97.                               VAR Esc_Found : BOOLEAN;
  98.                               VAR Number    : INTEGER );
  99.  
  100. (*----------------------------------------------------------------------*)
  101. (*                                                                      *)
  102. (*     Procedure:  Read_Number_Or_ESC                                   *)
  103. (*                                                                      *)
  104. (*     Purpose:    Reads in number and reports if escape hit.           *)
  105. (*                                                                      *)
  106. (*     Calling Sequence:                                                *)
  107. (*                                                                      *)
  108. (*        Read_Number_Or_ESC(     Ch        : CHAR;                     *)
  109. (*                                Xpos      : INTEGER;                  *)
  110. (*                            VAR SNumber   : AnyStr;                   *)
  111. (*                            VAR Pre_Str   : AnyStr;                   *)
  112. (*                            VAR Post_Str  : AnyStr;                   *)
  113. (*                            VAR Esc_Found : BOOLEAN;                  *)
  114. (*                            VAR Number    : INTEGER );                *)
  115. (*                                                                      *)
  116. (*           Ch        --- First character in number (input)            *)
  117. (*           XPos      --- First column of answer                       *)
  118. (*           SNumber   --- Full number if found                         *)
  119. (*           Pre_Str   --- Prefix string if any found                   *)
  120. (*           Post_Str  --- Postfix string if any found                  *)
  121. (*           Esc_Found --- Escape encountered                           *)
  122. (*           Number    --- Resultant number                             *)
  123. (*                                                                      *)
  124. (*     Calls:                                                           *)
  125. (*                                                                      *)
  126. (*        Menu_Beep                                                     *)
  127. (*                                                                      *)
  128. (*----------------------------------------------------------------------*)
  129.  
  130. VAR
  131.    IX      : INTEGER;
  132.    IY      : INTEGER;
  133.    Ierr    : INTEGER;
  134.  
  135. BEGIN (* Read_Number_Or_ESC *)
  136.  
  137.                                    (* Initialize arguments         *)
  138.    ESC_Found := FALSE;
  139.    SNumber   := '';
  140.    Pre_Str   := '';
  141.    Post_Str  := '';
  142.    Number    := 0;
  143.                                    (* Loop over input and pick up   *)
  144.                                    (* number, possibly with dialing *)
  145.                                    (* prefix, or ESC.               *)
  146.    REPEAT
  147.  
  148.       IF ( Ch <> CHR( CR ) ) AND ( Ch <> ';' ) THEN
  149.          BEGIN (* Not CR *)
  150.  
  151.             IF Ch = ^H THEN
  152.                BEGIN  (* Backspace *)
  153.                   IF WhereX > Xpos THEN
  154.                      BEGIN
  155.                         IY := WhereX;
  156.                         GoToXY( IY - 1 , WhereY );
  157.                         WRITE(' ');
  158.                         GoToXY( IY - 1 , WhereY );
  159.                         IF LENGTH( SNumber ) > 1 THEN
  160.                            SNumber := COPY( SNumber, 1, LENGTH( SNumber ) - 1 )
  161.                         ELSE
  162.                            SNumber := '';
  163.                      END;
  164.                END   (* Backspace *)
  165.             ELSE IF ( Ch = CHR( ESC ) ) THEN
  166.                BEGIN  (* Escape found *)
  167.                   ESC_Found := TRUE;
  168.                   SNumber   := '';
  169.                END    (* Escape found *)
  170.             ELSE
  171.                BEGIN
  172.                   SNumber := SNumber + Ch;
  173.                   WRITE( Ch );
  174.                END;
  175.  
  176.             IF ( NOT ESC_Found ) THEN
  177.                READ( Kbd, Ch );
  178.  
  179.          END (* Not CR *);
  180.  
  181.    UNTIL ( Ch = CHR( CR ) ) OR ( Ch = ';' ) OR ESC_Found;
  182.  
  183.                                    (* No number entered -- quit *)
  184.  
  185.    IF ( LENGTH( SNumber ) <= 0 ) OR ( ESC_Found ) THEN EXIT;
  186.  
  187.                                    (* Remove prefix if any *)
  188.  
  189.    IF SNumber[1] IN ['+','-','!','@','#'] THEN
  190.       BEGIN
  191.          Pre_Str    := Phone_Prefix_Nos[ POS( SNumber[1], '+-!@#' ) ];
  192.          SNumber    := COPY( SNumber, 2, LENGTH( SNumber ) - 1 );
  193.       END;
  194.                                    (* Remove postfix if any *)
  195.  
  196.    IF SNumber[LENGTH(SNumber)] IN ['+','-','!','@','#'] THEN
  197.       BEGIN
  198.          Post_Str   := Phone_Prefix_Nos[ POS( SNumber[LENGTH(SNumber)],
  199.                                               '+-!@#' ) ];
  200.          SNumber    := COPY( SNumber, 1, LENGTH( SNumber ) - 1 );
  201.       END;
  202.  
  203.                                    (* Convert number *)
  204.    Number := 0;
  205.    Ierr   := 0;
  206.  
  207.    FOR IX := 1 TO LENGTH( SNumber ) DO
  208.       IF SNumber[IX] IN ['0'..'9'] THEN
  209.          Number := Number * 10 + ORD( SNumber[IX] ) - ORD('0')
  210.       ELSE IF ( NOT ( UpCase( SNumber[IX] ) IN ['M','G'] ) ) THEN
  211.          Ierr := 1;
  212.                                    (* If bad, beep and ignore. *)
  213.    IF ( Ierr > 0 ) THEN
  214.       BEGIN
  215.          Menu_Beep;
  216.          EXIT;
  217.       END;
  218.  
  219. END   (* Read_Number_Or_ESC *);
  220.  
  221. (*----------------------------------------------------------------------*)
  222. (*    Reset_Comm_Params --- Reset comm. parms. from dialing entry       *)
  223. (*----------------------------------------------------------------------*)
  224.  
  225. PROCEDURE Reset_Comm_Params( Phone_Entry_Data: Phone_Number_Record ) ;
  226.  
  227. (*----------------------------------------------------------------------*)
  228. (*                                                                      *)
  229. (*     Procedure:  Reset_Comm_Params                                    *)
  230. (*                                                                      *)
  231. (*     Purpose:    Resets communications parameters (baud,parity,bits)  *)
  232. (*                 according to selected dialing directory entry.       *)
  233. (*                                                                      *)
  234. (*     Calling Sequence:                                                *)
  235. (*                                                                      *)
  236. (*        Reset_Comm_Params( Phone_Entry_Data: Phone_Number_Record );   *)
  237. (*                                                                      *)
  238. (*           Phone_Entry_Data --- data record for a dialing entry       *)
  239. (*                                                                      *)
  240. (*     Calls:                                                           *)
  241. (*                                                                      *)
  242. (*        Async_Reset_Port                                              *)
  243. (*                                                                      *)
  244. (*----------------------------------------------------------------------*)
  245.  
  246. VAR
  247.    Qerr: BOOLEAN;
  248.    S:    ShortStr;
  249.    I:    INTEGER;
  250.    J:    INTEGER;
  251.  
  252. BEGIN (* Reset_Comm_Params *)
  253.  
  254.    WITH Phone_Entry_Data DO
  255.       BEGIN
  256.  
  257.          S := Phone_Baud;
  258.  
  259.          I := 0;
  260.  
  261.          FOR J := 1 TO LENGTH( S ) DO
  262.             IF S[J] IN ['0'..'9'] THEN
  263.                I := I * 10 + ORD( S[J] ) - ORD('0');
  264.  
  265.          Baud_Rate := I;
  266.  
  267.          Parity := Phone_Parity;
  268.  
  269.          Data_Bits := ORD( Phone_DataBits ) - ORD('0');
  270.  
  271.          Stop_Bits := ORD( Phone_StopBits ) - ORD('0');
  272.  
  273.          Async_Reset_Port( Comm_Port, Baud_Rate,
  274.                            Parity, Data_Bits, Stop_Bits );
  275.  
  276.       END;
  277.  
  278. END   (* Reset_Comm_Params *);
  279.  
  280. (*----------------------------------------------------------------------*)
  281. (*         Display_Phone_Numbers --- display dialing directory          *)
  282. (*----------------------------------------------------------------------*)
  283.  
  284. PROCEDURE Display_Phone_Numbers( VAR Phone_Number: AnyStr;
  285.                                  VAR Prefix_Str  : AnyStr;
  286.                                  VAR Postfix_Str : AnyStr;
  287.                                  VAR Esc_Hit     : BOOLEAN );
  288.  
  289. (*----------------------------------------------------------------------*)
  290. (*                                                                      *)
  291. (*     Procedure:  Display_Phone_Numbers                                *)
  292. (*                                                                      *)
  293. (*     Purpose:    Displays dialing directory and prompts for # to dial *)
  294. (*                                                                      *)
  295. (*     Calling Sequence:                                                *)
  296. (*                                                                      *)
  297. (*        Display_Phone_Numbers( VAR Phone_Number: AnyStr;              *)
  298. (*                               VAR Prefix_Str  : AnyStr;              *)
  299. (*                               VAR Postfix_Str : AnyStr;              *)
  300. (*                               VAR Esc_Hit     : BOOLEAN );           *)
  301. (*                                                                      *)
  302. (*           Phone_Number --- phone number to dial (if any)             *)
  303. (*           Prefix_Str   --- prefix string to use                      *)
  304. (*           Postfix_Str  --- postfix string to use                     *)
  305. (*           Esc_Hit      --- TRUE if ESC hit to exit dialing           *)
  306. (*                                                                      *)
  307. (*     Calls:   Display_Directory_Page                                  *)
  308. (*              Save_Screen                                             *)
  309. (*              Restore_Screen                                          *)
  310. (*              Draw_Menu_Frame                                         *)
  311. (*              Reset_Global_Colors                                     *)
  312. (*              Dialer_Carrier_Detect                                   *)
  313. (*                                                                      *)
  314. (*----------------------------------------------------------------------*)
  315.  
  316. CONST
  317.    N_nos = 15                      (* No. of phone numbers displayed *);
  318.    Max_Dialing_Page = 14           (* Last page in dialing directory *);
  319.  
  320. VAR
  321.    Phone_Entries: ARRAY[ 1 .. N_Nos ] OF Phone_Number_Record;
  322.    Fixed_Entry  : Phone_Number_Record;
  323.    Low_Num      : INTEGER;
  324.    Hi_Num       : INTEGER;
  325.    Done         : BOOLEAN;
  326.    I            : INTEGER;
  327.    J            : INTEGER;
  328.    L            : INTEGER;
  329.    Dial_Func    : CHAR;
  330.    SNumber      : STRING[40];
  331.    Local_Save   : Saved_Screen_Ptr;
  332.    Local_Save_2 : Saved_Screen_Ptr;
  333.    Local_Save_3 : Saved_Screen_Ptr;
  334.    Qerr         : BOOLEAN;
  335.    XPos         : INTEGER;
  336.    YPos         : INTEGER;
  337.    ReDraw       : BOOLEAN;
  338.    Save_Pre     : ShortStr;
  339.    Save_Post    : ShortStr;
  340.    SS           : AnyStr;
  341.    Ch           : CHAR;
  342.    Q            : BOOLEAN;
  343.  
  344. (*----------------------------------------------------------------------*)
  345. (*   Display_Directory_Page --- display a page of phone directory       *)
  346. (*----------------------------------------------------------------------*)
  347.  
  348. PROCEDURE Display_Directory_Page;
  349.  
  350. (*----------------------------------------------------------------------*)
  351. (*                                                                      *)
  352. (*     Procedure:  Display_Directory_Page                               *)
  353. (*                                                                      *)
  354. (*     Purpose:    Displays one page of dialing directory               *)
  355. (*                                                                      *)
  356. (*     Calling Sequence:                                                *)
  357. (*                                                                      *)
  358. (*        Display_Directory_Page;                                       *)
  359. (*                                                                      *)
  360. (*     Calls:   None                                                    *)
  361. (*                                                                      *)
  362. (*----------------------------------------------------------------------*)
  363.  
  364. BEGIN (* Display_Directory_Page *)
  365.                                    (* Get to first line of display *)
  366.    GoToXY( 1 , 1 );
  367.                                    (* Pick up phone numbers        *)
  368.    L      := 0;
  369.  
  370.    FOR I := Low_Num TO Hi_Num DO
  371.       BEGIN
  372.             (*$I-*)
  373.          SEEK( Phone_File , I - 1 );
  374.             (*$I+*)
  375.          IF Int24Result = 0 THEN
  376.             BEGIN
  377.                L      := L + 1;
  378.                READ( Phone_File , Phone_Entries[ L ] );
  379.             END;
  380.       END;
  381.  
  382.                                    (* Display entries              *)
  383.  
  384.    RvsVideoOn( ForeGround_Color , BackGround_Color );
  385.  
  386.    FOR I := 1 TO L DO
  387.       WITH Phone_Entries[I] DO
  388.          BEGIN
  389.             J := Low_Num + I - 1;
  390.             WRITELN( J:3, '  ',  Phone_Name:25,  '  ',  Phone_Number:15,
  391.                           '   ', Phone_Baud:5,   '    ', Phone_DataBits:1,
  392.                           '      ', Phone_Parity:1, '     ', Phone_StopBits:1 );
  393.             RvsVideoOff( ForeGround_Color , BackGround_Color );
  394.          END;
  395.                                    (* Blank out any remaining lines *)
  396.    FOR I := ( L + 1 ) TO N_Nos DO
  397.       BEGIN
  398.          GoToXY( 1 , I );
  399.          ClrEol;
  400.       END;
  401.  
  402. END   (* Display_Directory_Page *);
  403.  
  404. (*----------------------------------------------------------------------*)
  405. (*          Revise_Phone_Entry --- Revise phone directory entry         *)
  406. (*----------------------------------------------------------------------*)
  407.  
  408. PROCEDURE Revise_Phone_Entry;
  409.  
  410. (*----------------------------------------------------------------------*)
  411. (*                                                                      *)
  412. (*     Procedure:  Revise_Phone_Entry                                   *)
  413. (*                                                                      *)
  414. (*     Purpose:    Handles revision of dialing directory entry          *)
  415. (*                                                                      *)
  416. (*     Calling Sequence:                                                *)
  417. (*                                                                      *)
  418. (*        Revise_Phone_Entry;                                           *)
  419. (*                                                                      *)
  420. (*     Calls:   Save_Screen                                             *)
  421. (*              Draw_Menu_Frame                                         *)
  422. (*              Save_Screen                                             *)
  423. (*              Restore_Screen                                          *)
  424. (*                                                                      *)
  425. (*----------------------------------------------------------------------*)
  426.  
  427. VAR
  428.    J:    INTEGER;
  429.    Quit: BOOLEAN;
  430.    Ch  : CHAR;
  431.  
  432. BEGIN (* Revise_Phone_Entry *)
  433.                                    (* Get number to revise *)
  434.    Save_Screen( Local_Save_2 );
  435.  
  436.    Window( 1, 1, 80, 25 );
  437.  
  438.    Draw_Menu_Frame( 10, 2, 51, 6, Menu_Frame_Color,
  439.                     Menu_Text_Color, 'Revise Dialing Entry');
  440.  
  441.    Quit := FALSE;
  442.                                    (* Request the entry number *)
  443.  
  444.    WRITE('Entry to revise ? ');
  445.    READ( Kbd , Ch );
  446.  
  447.    Read_Number_Or_ESC( Ch , WhereX - 1, SNumber, Prefix_Str, PostFix_Str,
  448.                        Quit, J );
  449.  
  450.                                    (* Exit if none entered *)
  451.    IF  ( Quit OR ( J <= 0 ) ) THEN
  452.       BEGIN
  453.          Restore_Screen( Local_Save_2 );
  454.          EXIT;
  455.       END;
  456.                                    (* Look for it on file  *)
  457.        (*$I-*)
  458.    SEEK( Phone_File , J - 1 );
  459.        (*$I+*)
  460.                                    (* If not found, quit revision *)
  461.    IF Int24Result <> 0 THEN
  462.       BEGIN
  463.          WRITELN;
  464.          WRITELN('No such entry.');
  465.          DELAY( Two_Second_Delay );
  466.       END
  467.    ELSE                            (* Otherwise pick up entry's data *)
  468.       BEGIN (* Entry exists *)
  469.  
  470.          READ( Phone_File , Fixed_Entry );
  471.  
  472.          Restore_Screen( Local_Save_2 );
  473.  
  474.                                    (* Bring up revision window *)
  475.          Save_Screen( Local_Save_2 );
  476.  
  477.          Window( 1, 1, 80, 25 );
  478.  
  479.          Draw_Menu_Frame( 10, 2, 51, 23, Menu_Frame_Color,
  480.                           Menu_Text_Color, 'Revise Dialing Entry ');
  481.  
  482.          Window( 11, 3, 50, 22 );
  483.                                    (* Read in revisions *)
  484.          WITH Fixed_Entry DO
  485.             BEGIN  (* Get revisions *)
  486.  
  487.                GoToXY ( 2 , 2 );
  488.                WRITELN('Old Name: ', Phone_Name );
  489.  
  490.                GoToXY( 2 , 3 );
  491.                WRITE ('New Name: ');
  492.                READLN( SNumber );
  493.  
  494.                IF LENGTH( SNumber ) > 0 THEN
  495.                   CopyStoA( SNumber , Phone_Name , 25 );
  496.  
  497.                GoToXY ( 2 , 5 );
  498.                WRITELN('Old Number: ', Phone_Number );
  499.  
  500.                GoToXY( 2 , 6 );
  501.                WRITE ('New Number: ');
  502.                READLN( SNumber );
  503.  
  504.                IF LENGTH( SNumber ) > 0 THEN
  505.                   CopyS2AR( SNumber , Phone_Number , 15 );
  506.  
  507.                GoToXY( 2 , 8 );
  508.                WRITELN('Old Baud Rate: ', Phone_Baud );
  509.  
  510.                GoToXY( 2 , 9 );
  511.                WRITE ('New Baud Rate: ');
  512.                READLN( SNumber );
  513.  
  514.                IF LENGTH( SNumber ) > 0 THEN
  515.                   CopyS2AR( SNumber , Phone_Baud, 5 );
  516.  
  517.                GoToXY( 2 , 11 );
  518.                WRITELN('Old Parity: ', Phone_Parity );
  519.  
  520.                GoToXY( 2 , 12 );
  521.                WRITE ('New Parity: ');
  522.                READLN( SNumber );
  523.  
  524.                IF LENGTH( SNumber ) > 0 THEN
  525.                   IF UpCase( SNumber[1] ) IN ['E','O','N'] THEN
  526.                      Phone_Parity := UpCase(SNumber[1]);
  527.  
  528.                GoToXY ( 2 , 14 );
  529.                WRITELN('Old Data Bits: ', Phone_DataBits );
  530.  
  531.                GoToXY ( 2 , 15 );
  532.                WRITE  ('New Data Bits: ');
  533.                READLN ( SNumber );
  534.  
  535.                IF LENGTH( SNumber ) > 0 THEN
  536.                   IF SNumber[1] IN ['5'..'8'] THEN
  537.                      Phone_DataBits := SNumber[1];
  538.  
  539.                GoToXY( 2 , 17 );
  540.                WRITELN('Old Stop Bits: ', Phone_StopBits );
  541.  
  542.                GoToXY( 2 , 18 );
  543.                WRITE  ('New Stop Bits: ');
  544.                READLN( SNumber );
  545.  
  546.                IF LENGTH( SNumber ) > 0 THEN
  547.                   IF SNumber[1] IN ['1'..'2'] THEN
  548.                      Phone_StopBits := SNumber[1];
  549.  
  550.                                    (* Write revised entry back to *)
  551.                                    (* phone directory file        *)
  552.  
  553.                SEEK ( Phone_File , J - 1 );
  554.                WRITE( Phone_File , Fixed_Entry );
  555.  
  556.                Restore_Screen( Local_Save_2 );
  557.  
  558.             END (* Get Revisions *);
  559.  
  560.       END (* Entry exists *);
  561.  
  562. END   (* Revise_Phone_Entry *);
  563.  
  564. (*----------------------------------------------------------------------*)
  565. (*            Revise_Dialing_Prefix --- Revise dialing prefix           *)
  566. (*----------------------------------------------------------------------*)
  567.  
  568. PROCEDURE Revise_Dialing_Prefix;
  569.  
  570. (*----------------------------------------------------------------------*)
  571. (*                                                                      *)
  572. (*     Procedure:  Revise_Dialing_Prefix                                *)
  573. (*                                                                      *)
  574. (*     Purpose:    Handles revision of dialing prefix or setting of     *)
  575. (*                 default prefix.                                      *)
  576. (*                                                                      *)
  577. (*     Calling Sequence:                                                *)
  578. (*                                                                      *)
  579. (*        Revise_Dialing_Prefix;                                        *)
  580. (*                                                                      *)
  581. (*     Calls:   Save_Screen                                             *)
  582. (*              Draw_Menu_Frame                                         *)
  583. (*              Save_Screen                                             *)
  584. (*              Restore_Screen                                          *)
  585. (*              Get_New_Dialing_Prefix                                  *)
  586. (*              Get_New_Default_Prefix                                  *)
  587. (*                                                                      *)
  588. (*----------------------------------------------------------------------*)
  589.  
  590. VAR
  591.    Prefix_Menu  : Menu_Type;
  592.  
  593. (*----------------------------------------------------------------------*)
  594.  
  595. PROCEDURE Get_New_Dialing_Prefix;
  596.  
  597. VAR
  598.    I:       INTEGER;
  599.    Done:    BOOLEAN;
  600.    Pchar:   CHAR;
  601.    Changed: BOOLEAN;
  602.  
  603. BEGIN (* Get_New_Dialing_Prefix *)
  604.  
  605.                                    (* Bring up revision window *)
  606.    Save_Screen( Local_Save_2 );
  607.  
  608.    Window( 1, 1, 80, 25 );
  609.  
  610.    Draw_Menu_Frame( 10, 2, 65, 10, Menu_Frame_Color,
  611.                     Menu_Text_Color, 'Revise Dialing Prefix');
  612.  
  613.    Window( 11, 3, 64, 9 );
  614.  
  615.    Done    := FALSE;
  616.    Changed := FALSE;
  617.  
  618.    REPEAT
  619.  
  620.       GoToXY( 1 , 2 );
  621.  
  622.       FOR I := 1 TO Max_Phone_Prefixes DO
  623.          BEGIN
  624.             ClrEol;
  625.             WRITELN( ' ', Phone_Prefix_Chars[I], ' = ', Phone_Prefix_Nos[I] );
  626.          END;
  627.  
  628.       WRITELN(' ');
  629.  
  630.       REPEAT
  631.          GoToXY( 2 , WhereY );
  632.          WRITE('Enter prefix character to revise: ');
  633.          ClrEol;
  634.          READ( Kbd, Pchar );
  635.          IF NOT ( Pchar IN ['+','-','!','@','#',CHR(CR)] ) THEN
  636.             Menu_Beep;
  637.       UNTIL( Pchar IN ['+','-','!','@','#',CHR(CR)] );
  638.  
  639.       IF Pchar <> CHR(CR) THEN
  640.          BEGIN
  641.  
  642.             GoToXY( 2 , WhereY );
  643.             WRITE('Enter new prefix for ',Pchar,':');
  644.             ClrEol;
  645.  
  646.             READLN( SNumber );
  647.  
  648.             Phone_Prefix_Nos[ POS( Pchar , '+-!@#' ) ] := Read_Ctrls( SNumber );
  649.  
  650.             Changed := TRUE;
  651.  
  652.          END
  653.       ELSE
  654.          Done := TRUE;
  655.  
  656.    UNTIL( Done );
  657.                                    (* Rewrite prefix file if changed *)
  658.  
  659.    IF Changed THEN
  660.       BEGIN
  661.  
  662.          ASSIGN( Phone_Prefix_File , Home_Dir + 'PIBTERM.PRE' );
  663.                    (*$I-*)
  664.          REWRITE( Phone_Prefix_File );
  665.                    (*$I+*)
  666.  
  667.          ClrScr;
  668.  
  669.          IF Int24Result <> 0 THEN
  670.             WRITELN(' Can''t create revised PIBTERM.PRE')
  671.          ELSE
  672.             BEGIN
  673.  
  674.                WRITELN(' Writing revised PIBTERM.PRE -- phone prefix file.');
  675.  
  676.                FOR I := 1 TO Max_Phone_Prefixes DO
  677.                   WRITELN( Phone_Prefix_File ,
  678.                            Write_Ctrls( Phone_Prefix_Nos[ I ] ) );
  679.  
  680.                CLOSE( Phone_Prefix_File );
  681.  
  682.             END;
  683.  
  684.          DELAY( Two_Second_Delay );
  685.  
  686.       END;
  687.  
  688.    Restore_Screen( Local_Save_2 );
  689.  
  690. END   (* Get_New_Dialing_Prefix *);
  691.  
  692. (*----------------------------------------------------------------------*)
  693.  
  694. PROCEDURE Get_New_Default_Prefix;
  695.  
  696. VAR
  697.    Done:  BOOLEAN;
  698.    Pchar: CHAR;
  699.  
  700. BEGIN (* Get_New_Default_Prefix *)
  701.                                    (* Bring up revision window *)
  702.    Save_Screen( Local_Save_2 );
  703.  
  704.    Window( 1, 1, 80, 25 );
  705.  
  706.    Draw_Menu_Frame( 10, 10, 65, 15, Menu_Frame_Color,
  707.                     Menu_Text_Color, 'Set Default Dialing Prefix');
  708.  
  709.    Window( 11, 11, 64, 14 );
  710.  
  711.    Done := FALSE;
  712.  
  713.    REPEAT
  714.       GoToXY( 1 , WhereY );
  715.       WRITE('Enter default prefix character: ');
  716.       ClrEol;
  717.       READ( Kbd, Pchar );
  718.       WRITE( Pchar );
  719.       IF NOT ( Pchar IN ['+','-','!','@','#',CHR(CR)] ) THEN
  720.          Menu_Beep;
  721.    UNTIL( Pchar IN ['+','-','!','@','#',CHR(CR)] );
  722.  
  723.    IF Pchar <> CHR(CR) THEN
  724.       Default_Prefix := Pchar
  725.    ELSE
  726.       Default_Prefix := ' ';
  727.  
  728.    DELAY( One_Second_Delay );
  729.  
  730.    Restore_Screen( Local_Save_2 );
  731.  
  732. END   (* Get_New_Default_Prefix *);
  733.  
  734. (*----------------------------------------------------------------------*)
  735.  
  736. PROCEDURE Get_New_Default_Postfix;
  737.  
  738. VAR
  739.    Done:  BOOLEAN;
  740.    Pchar: CHAR;
  741.  
  742. BEGIN (* Get_New_Default_Postfix *)
  743.                                    (* Bring up revision window *)
  744.    Save_Screen( Local_Save_2 );
  745.  
  746.    Window( 1, 1, 80, 25 );
  747.  
  748.    Draw_Menu_Frame( 10, 10, 65, 15, Menu_Frame_Color,
  749.                     Menu_Text_Color, 'Set Default Dialing Postfix');
  750.  
  751.    Window( 11, 11, 64, 14 );
  752.  
  753.    Done := FALSE;
  754.  
  755.    REPEAT
  756.       GoToXY( 1 , WhereY );
  757.       WRITE('Enter default postfix character: ');
  758.       ClrEol;
  759.       READ( Kbd, Pchar );
  760.       WRITE( Pchar );
  761.       IF NOT ( Pchar IN ['+','-','!','@','#',CHR(CR)] ) THEN
  762.          Menu_Beep;
  763.    UNTIL( Pchar IN ['+','-','!','@','#',CHR(CR)] );
  764.  
  765.    IF Pchar <> CHR(CR) THEN
  766.       Default_Postfix := Pchar
  767.    ELSE
  768.       Default_Postfix := ' ';
  769.  
  770.    DELAY( One_Second_Delay );
  771.  
  772.    Restore_Screen( Local_Save_2 );
  773.  
  774. END   (* Get_New_Default_Postfix *);
  775.  
  776. (*----------------------------------------------------------------------*)
  777.  
  778. BEGIN (* Revise_Dialing_Prefix *)
  779.                                    (* Bring up revision menu *)
  780.    WITH Prefix_Menu DO
  781.       BEGIN
  782.  
  783.          Menu_Size    := 3;
  784.          Menu_Default := 1;
  785.          Menu_Row     := 11;
  786.          Menu_Column  := 30;
  787.          Menu_Tcolor  := Menu_Text_Color;
  788.          Menu_Bcolor  := BackGround_Color;
  789.          Menu_Fcolor  := Menu_Frame_Color;
  790.          Menu_Width   := 0;
  791.          Menu_Height  := 0;
  792.  
  793.       END (* WITH Prefix_Menu *);
  794.  
  795.    FOR I := 1 TO 3 DO
  796.       WITH Prefix_Menu.Menu_Entries[I] DO
  797.       BEGIN
  798.          Menu_Item_Row    := I;
  799.          Menu_Item_Column := 2;
  800.          CASE I OF
  801.             1:  Menu_Item_Text := 'a) Revise prefix string';
  802.             2:  Menu_Item_Text := 'b) Set default prefix';
  803.             3:  Menu_Item_Text := 'c) Set default postfix';
  804.          END (* CASE *);
  805.       END;
  806.  
  807.    Prefix_Menu.Menu_Title := 'Choose prefix revision function:';
  808.  
  809.    Menu_Display_Choices( Prefix_Menu );
  810.  
  811.    CASE Menu_Get_Choice( Prefix_Menu , Erase_Menu ) OF
  812.       1: Get_New_Dialing_Prefix;
  813.       2: Get_New_Default_Prefix;
  814.       3: Get_New_Default_Postfix;
  815.    END (* Case *);
  816.  
  817. END   (* Revise_Dialing_Prefix *);
  818.  
  819. (*----------------------------------------------------------------------*)
  820. (*            Clear_Dialing_Entry --- Clear dialing entry               *)
  821. (*----------------------------------------------------------------------*)
  822.  
  823. PROCEDURE Clear_Dialing_Entry;
  824.  
  825. (*----------------------------------------------------------------------*)
  826. (*                                                                      *)
  827. (*     Procedure:  Clear_Dialing_Entry                                  *)
  828. (*                                                                      *)
  829. (*     Purpose:    Clear out entry in dialing directory                 *)
  830. (*                                                                      *)
  831. (*     Calling Sequence:                                                *)
  832. (*                                                                      *)
  833. (*        Clear_Dialing_Entry;                                          *)
  834. (*                                                                      *)
  835. (*     Calls:   CopySToA                                                *)
  836. (*              Menu_Beep                                               *)
  837. (*                                                                      *)
  838. (*----------------------------------------------------------------------*)
  839.  
  840. BEGIN (* Clear_Dialing_Entry *)
  841.  
  842.                                    (* Bring up clear entry window *)
  843.    Save_Screen( Local_Save_2 );
  844.  
  845.    Window( 1, 1, 80, 25 );
  846.  
  847.    Draw_Menu_Frame( 10, 2, 65, 5, Menu_Frame_Color,
  848.                     Menu_Text_Color, 'Clear Entry');
  849.  
  850.    Window( 11, 3, 64, 4 );
  851.  
  852.    GoToXY( 1 , 1 );
  853.                                    (* Get entry to clear out *)
  854.  
  855.    WRITE('Enter # of entry to clear: ');
  856.       (*$I-*)
  857.    READLN( SNumber );
  858.       (*$I+*)
  859.  
  860.    VAL( SNumber, I, J );
  861.                                    (* Check if legitimate *)
  862.    IF ( J = 0 ) AND
  863.       ( I > 0 ) AND ( I < Default_Phone_Number_Size ) THEN
  864.       BEGIN
  865.                                    (* If so, clear it     *)
  866.          WITH Phone_Entry_Data DO
  867.             BEGIN
  868.  
  869.                CopyStoA( Dupl( '-' , 25 ) , Phone_Name ,   25 );
  870.                CopyStoA( ' # ### ###-####' , Phone_Number , 15 );
  871.  
  872.                Phone_Parity   := ' ';
  873.                Phone_Baud     := ' ----';
  874.                Phone_DataBits := ' ';
  875.                Phone_StopBits := ' ';
  876.  
  877.             END;
  878.  
  879.          SEEK ( Phone_File , I - 1 );
  880.          WRITE( Phone_File , Phone_Entry_Data );
  881.  
  882.       END
  883.    ELSE
  884.       Menu_Beep;
  885.  
  886.    Restore_Screen( Local_Save_2 );
  887.  
  888. END   (* Clear_Dialing_Entry *);
  889.  
  890. (*----------------------------------------------------------------------*)
  891. (*            Extract_Dialing_Entry --- Get number to dial              *)
  892. (*----------------------------------------------------------------------*)
  893.  
  894. PROCEDURE Extract_Dialing_Entry( I: INTEGER );
  895.  
  896. (*----------------------------------------------------------------------*)
  897. (*                                                                      *)
  898. (*     Procedure:  Extract_Dialing_Entry                                *)
  899. (*                                                                      *)
  900. (*     Purpose:    Read entry from dialing directory file               *)
  901. (*                                                                      *)
  902. (*     Calling Sequence:                                                *)
  903. (*                                                                      *)
  904. (*        Extract_Dialing_Entry( I : INTEGER );                         *)
  905. (*                                                                      *)
  906. (*           I --- If  > 0, then entry to dial;                         *)
  907. (*                 If <= 0, then get entry from input.                  *)
  908. (*                                                                      *)
  909. (*     Calls:   Reset_Comm_Params                                       *)
  910. (*                                                                      *)
  911. (*     Remarks:                                                         *)
  912. (*                                                                      *)
  913. (*        The current communications parameters are reset to match      *)
  914. (*        present in the selected dialing directory entry.              *)
  915. (*                                                                      *)
  916. (*----------------------------------------------------------------------*)
  917.  
  918. VAR
  919.    OK_Number: BOOLEAN;
  920.    Ch       : CHAR;
  921.    IX       : INTEGER;
  922.    IY       : INTEGER;
  923.    Quit     : BOOLEAN;
  924.    Use_DP   : BOOLEAN;
  925.  
  926. BEGIN (* Extract_Dialing_Entry *)
  927.                                    (* Initialize dialing entry *)
  928.    SNumber     := '';
  929.    Prefix_Str  := '';
  930.    Postfix_Str := '';
  931.  
  932.    Quit       := FALSE;
  933.    Use_DP     := FALSE;
  934.                                    (* We entered with first character *)
  935.                                    (* in Dial_Func if I <= 0.         *)
  936.  
  937.    IF I <= 0 THEN
  938.       Read_Number_Or_ESC( Dial_Func, Xpos, SNumber, Prefix_Str, Postfix_Str,
  939.                           Quit, I )
  940.    ELSE
  941.       Use_DP := Default_Prefix <> ' ';
  942.  
  943.  
  944.                                    (* No number entered -- quit *)
  945.    IF ( Quit OR ( I <= 0 ) ) THEN EXIT;
  946.  
  947.                                    (* Extract phone number from directory *)
  948.       (*$I-*)
  949.    SEEK( Phone_File , I - 1 );
  950.       (*$I+*)
  951.  
  952.    IF ( Int24Result <> 0 ) THEN EXIT;
  953.  
  954.    READ( Phone_File , Phone_Entry_Data );
  955.  
  956.    Phone_Number := Phone_Entry_Data.Phone_Number;
  957.  
  958.                                    (* Use default dialing prefix if       *)
  959.                                    (* number is > 7 digits.               *)
  960.    IF Use_DP THEN
  961.       BEGIN
  962.          IX := 0;
  963.          FOR I := 1 TO LENGTH( Phone_Number ) DO
  964.             IF ( Phone_Number[I] IN ['0'..'9'] ) THEN
  965.                IX := IX + 1;
  966.          IF ( IX > 7 ) THEN
  967.             Prefix_Str := Phone_Prefix_Nos[ POS( Default_Prefix, '+-!@#' ) ];
  968.       END;
  969.  
  970.                                    (* Add in default postfix if any *)
  971.  
  972.    IF ( Default_Postfix <> ' ' ) THEN
  973.       Postfix_Str := Phone_Prefix_Nos[ POS( Default_Postfix, '+-!@#' ) ];
  974.  
  975.    Done := TRUE;
  976.                                    (* If session not already in progress, *)
  977.                                    (* change comm parms to match dialing  *)
  978.                                    (* directory entry.                    *)
  979.  
  980.    IF ( NOT Dialer_Carrier_Detect ) THEN
  981.       Reset_Comm_Params( Phone_Entry_Data );
  982.  
  983. END   (* Extract_Dialing_Entry *);
  984.  
  985. (*----------------------------------------------------------------------*)
  986. (*     Do_Manual_Dial --- Get number to dial from keyboard entry        *)
  987. (*----------------------------------------------------------------------*)
  988.  
  989. FUNCTION Do_Manual_Dial : BOOLEAN;
  990.  
  991. VAR
  992.    Local_Save_5 : Saved_Screen_Ptr;
  993.    Ch           : CHAR;
  994.    Quit         : BOOLEAN;
  995.    J            : INTEGER;
  996.  
  997. BEGIN (* Do_Manual_Dial *)
  998.  
  999.    Save_Screen( Local_Save_5 );
  1000.  
  1001.    Window( 1, 1, 80, 25 );
  1002.  
  1003.    Draw_Menu_Frame( 10, 10, 65, 13, Menu_Frame_Color,
  1004.                     Menu_Text_Color, 'Manual Dial');
  1005.  
  1006.    Window( 11, 11, 64, 12 );
  1007.  
  1008.    GoToXY( 1 , 1 );
  1009.  
  1010.    Prefix_Str  := '';
  1011.    Postfix_Str := '';
  1012.    SNumber     := '';
  1013.  
  1014.    WRITE('Number to dial? ');
  1015.    READ( Kbd , Ch );
  1016.  
  1017.    Read_Number_Or_ESC( Ch , WhereX - 1, SNumber, Prefix_Str, PostFix_Str,
  1018.                        Quit, J );
  1019.  
  1020.    Restore_Screen( Local_Save_5 );
  1021.  
  1022.    IF ( NOT Quit ) AND ( LENGTH( SNumber ) > 0 ) THEN
  1023.       BEGIN
  1024.          Phone_Number   := SNumber;
  1025.          Do_Manual_Dial := TRUE;
  1026.          Manual_Dial    := TRUE;
  1027.          FOR I := 1 TO 25 DO
  1028.             Phone_Entry_Data.Phone_Name[I] := ' ';
  1029.       END
  1030.    ELSE
  1031.       Do_Manual_Dial := FALSE;
  1032.  
  1033. END   (* Do_Manual_Dial *);
  1034.  
  1035. (*----------------------------------------------------------------------*)
  1036. (*     Get_List_Of_Phone_Numbers --- Get list of entries to dial        *)
  1037. (*----------------------------------------------------------------------*)
  1038.  
  1039. PROCEDURE Get_List_Of_Phone_Numbers;
  1040.  
  1041. VAR
  1042.    No_Num  : BOOLEAN;
  1043.    SS_Num  : AnyStr;
  1044.  
  1045. BEGIN (* Get_List_Of_Phone_Numbers *)
  1046.  
  1047.    N_Dial_Nos := 0;
  1048.    No_Num     := FALSE;
  1049.  
  1050.    WHILE ( ( N_Dial_Nos < Max_Dial_Nos ) AND ( NOT No_Num ) ) DO
  1051.       BEGIN
  1052.                                    (* Increment dialing number count *)
  1053.  
  1054.          N_Dial_Nos := N_Dial_Nos + 1;
  1055.  
  1056.                                    (* Read in number *)
  1057.  
  1058.          WRITE('Enter phone number ',N_Dial_Nos:2,': ');
  1059.          READLN( SS_Num );
  1060.                                    (* Empty line terminates list entry *)
  1061.  
  1062.          IF LENGTH( SS_Num ) <= 0 THEN
  1063.             BEGIN
  1064.                No_Num     := TRUE;
  1065.                N_Dial_Nos := N_Dial_Nos - 1;
  1066.             END
  1067.          ELSE
  1068.                                    (* Store number *)
  1069.  
  1070.             Dial_Nos[N_Dial_Nos] := SS_Num;
  1071.  
  1072.       END;
  1073.  
  1074. END   (* Get_List_Of_Phone_Numbers *);
  1075.  
  1076. (*----------------------------------------------------------------------*)
  1077.  
  1078.  
  1079. BEGIN (* Display_Phone_Numbers *)
  1080.  
  1081.                                    (* Save dialing box screen *)
  1082.    Save_Screen( Local_Save );
  1083.                                    (* Get back whole screen as window *)
  1084.                                    (* for dialing display             *)
  1085.    Window( 1, 1, 80, 25 );
  1086.  
  1087.    ClrScr;
  1088.  
  1089.    Draw_Menu_Frame( 1, 1, 79, 25, Menu_Frame_Color,
  1090.                     Menu_Text_Color, 'Dialing Directory' );
  1091.  
  1092.    Window( 2, 2, 78, 24 );
  1093.                                    (* Display title                *)
  1094.  
  1095.    WRITELN('No.  --------- Name ----------',
  1096.            '   --- Number ---   -Baud- -Bits- -Par- -Stp- ');
  1097.    WRITELN(' ');
  1098.  
  1099.    Window( 2, 4, 78, 24 );
  1100.  
  1101.    GoToXY( 1 , N_Nos + 2 );
  1102.    TextColor( Menu_Frame_Color );
  1103.    WRITE  (' -->     R');
  1104.    TextColor( Menu_Text_Color );
  1105.    WRITE  (' Revise entry   ');
  1106.    TextColor( Menu_Frame_Color );
  1107.    WRITE  (' P');
  1108.    TextColor( Menu_Text_Color );
  1109.    WRITE  (' Revise prefix   ');
  1110.    TextColor( Menu_Frame_Color );
  1111.    WRITE  (' C');
  1112.    TextColor( Menu_Text_Color );
  1113.    WRITE  (' Clear entry');
  1114.    TextColor( Menu_Frame_Color );
  1115.    WRITE  ('    Q');
  1116.    TextColor( Menu_Text_Color );
  1117.    WRITELN(' Redial');
  1118.  
  1119.    TextColor( Menu_Frame_Color );
  1120.    WRITE  ('         PgUp/PgDn');
  1121.    TextColor( Menu_Text_Color );
  1122.    WRITE  (' Page');
  1123.    TextColor( Menu_Frame_Color );
  1124.    WRITE  ('    Esc');
  1125.    TextColor( Menu_Text_Color );
  1126.    WRITE  (' Exit        ');
  1127.    TextColor( Menu_Frame_Color );
  1128.    WRITE  ('   /');
  1129.    TextColor( Menu_Text_Color );
  1130.    WRITE  (' Scroll');
  1131.    TextColor( Menu_Frame_Color );
  1132.    WRITE  ('       H');
  1133.    TextColor( Menu_Text_Color );
  1134.    WRITELN(' Hang up');
  1135.  
  1136.    TextColor( Menu_Frame_Color );
  1137.    WRITE  ('         M ');
  1138.    TextColor( Menu_Text_Color );
  1139.    WRITE  ('Manual dial');
  1140.    TextColor( Menu_Frame_Color );
  1141.    WRITE  ('     Home ');
  1142.    TextColor( Menu_Text_Color );
  1143.    WRITE  ('First page ');
  1144.    TextColor( Menu_Frame_Color );
  1145.    WRITE  ('   End');
  1146.    TextColor( Menu_Text_Color );
  1147.    WRITE  (' Last page');
  1148.    TextColor( Menu_Frame_Color );
  1149.    WRITE  ('    G');
  1150.    TextColor( Menu_Text_Color );
  1151.    WRITELN(' Goto page');
  1152.  
  1153.    WRITE  ('         Entry');
  1154.    WRITE  (' to dial     ');
  1155.    TextColor( Menu_Frame_Color );
  1156.    WRITE  ('ENTER ');
  1157.    TextColor( Menu_Text_Color );
  1158.    WRITE('dials highlighted entry');
  1159.    TextColor( Menu_Frame_Color );
  1160.    WRITE  ('       L ');
  1161.    TextColor( Menu_Text_Color );
  1162.    WRITELN('Dial list');
  1163.  
  1164.    Low_Num      := MIN( MAX( Phone_Entry_Page , 1 ) ,
  1165.                              Default_Phone_Number_Size );
  1166.    Hi_Num       := MIN( Low_Num + N_Nos - 1 , Default_Phone_Number_Size );
  1167.    Done         := FALSE;
  1168.  
  1169.    N_Dial_Nos   := 0;
  1170.  
  1171.    Esc_Hit      := FALSE;
  1172.    ReDraw       := TRUE;
  1173.                                    (* Display dialing directory until    *)
  1174.                                    (* explicit exit requested or a       *)
  1175.                                    (* phone number selected for dialing  *)
  1176.    REPEAT
  1177.  
  1178.       IF ReDraw THEN
  1179.          BEGIN
  1180.             Display_Directory_Page;
  1181.             GoToXY( 5 , N_Nos + 2 );
  1182.             XPos      := WhereX;
  1183.             YPos      := WhereY;
  1184.             Dial_Func := ' ';
  1185.          END;
  1186.  
  1187.       ReDraw    := TRUE;
  1188.                                    (* Read in dialing command *)
  1189.       GoToXY( Xpos, Ypos );
  1190.  
  1191.       FOR I := 1 TO 5 DO
  1192.          WRITE(' ');
  1193.  
  1194.       GoToXY( Xpos, Ypos );
  1195.                                    (* Get function to perform *)
  1196.       READ( KBD , Dial_Func );
  1197.       Dial_Func := UpCase( Dial_Func );
  1198.  
  1199.                                    (* Check for keypad key *)
  1200.  
  1201.       IF ( ORD( Dial_Func ) = ESC ) AND KeyPressed THEN
  1202.          BEGIN
  1203.  
  1204.             READ( KBD , Dial_Func );
  1205.  
  1206.             CASE ORD( Dial_Func ) OF
  1207.  
  1208.                PgUp:    Dial_Func := 'B';
  1209.                PgDn:    Dial_Func := 'F';
  1210.                U_Arrow: Dial_Func := 'U';
  1211.                D_Arrow: Dial_Func := 'D';
  1212.                End_Key: Dial_Func := 'E';
  1213.                Home:    Dial_Func := 'T';
  1214.                ELSE     Dial_Func := 'Z';
  1215.  
  1216.             END (* CASE *)
  1217.  
  1218.          END
  1219.                                    (* flag invalid letters *)
  1220.  
  1221.       ELSE IF( NOT ( Dial_Func IN ['C','R','P',^[,^H,'0'..'9','+','-','!','@',
  1222.                                    '#',' ',^M, 'M','L','H','Q','G' ] ) ) THEN
  1223.          Dial_Func := 'Z';
  1224.  
  1225.                                    (* Perform requested dialing command *)
  1226.  
  1227.       CASE Dial_Func OF
  1228.  
  1229.                                    (* Clear dialing entry        *)
  1230.          'C':     Clear_Dialing_Entry;
  1231.  
  1232.                                    (* Exit without dialing anything *)
  1233.          ^[ :     BEGIN
  1234.                      Done    := TRUE;
  1235.                      Esc_Hit := TRUE;
  1236.                   END;
  1237.  
  1238.                                    (* Display next page in directory *)
  1239.  
  1240.          'F':     IF Hi_Num < Default_Phone_Number_Size THEN
  1241.                      BEGIN
  1242.                         Low_Num := Hi_Num + 1;
  1243.                         Hi_Num  := MIN( Low_Num + N_Nos - 1 ,
  1244.                                         Default_Phone_Number_Size );
  1245.                      END;
  1246.  
  1247.                                    (* Display previous page in directory *)
  1248.  
  1249.          'B':     IF Low_Num > 1 THEN
  1250.                      BEGIN
  1251.                         Low_Num := MAX( Low_Num - N_Nos , 1 );
  1252.                         Hi_Num  := MIN( Low_Num + N_Nos - 1 ,
  1253.                                         Default_Phone_Number_Size );
  1254.                      END;
  1255.  
  1256.                                    (* Display first page in directory *)
  1257.  
  1258.          'T':     BEGIN
  1259.                      Low_Num := 1;
  1260.                      Hi_Num  := N_Nos;
  1261.                   END;
  1262.  
  1263.                                    (* Display last page in directory *)
  1264.  
  1265.          'E':     BEGIN
  1266.                      Hi_Num  := Default_Phone_Number_Size;
  1267.                      Low_Num := MAX( Hi_Num - N_Nos + 1 , 1 );
  1268.                   END;
  1269.  
  1270.                                    (* Go to specific page in directory *)
  1271.  
  1272.          'G':     BEGIN
  1273.                      Ch := 'G';
  1274.                      Read_Number_Or_ESC( Ch , WhereX - 1, SS, SS, SS, Q, J );
  1275.                      IF ( NOT Q ) THEN
  1276.                         BEGIN
  1277.                            Low_Num := MAX( 0 , MIN( J , Max_Dialing_Page ) );
  1278.                            Low_Num := ( Low_Num - 1 ) * N_Nos + 1;
  1279.                            Hi_Num  := MIN( Low_Num + N_Nos - 1 ,
  1280.                                            Default_Phone_Number_Size );
  1281.                         END;
  1282.                   END;
  1283.  
  1284.          'U':     BEGIN (* Scroll up one line *)
  1285.  
  1286.                      Redraw := FALSE;
  1287.  
  1288.                      IF Low_Num > 1 THEN
  1289.                         BEGIN
  1290.  
  1291.                            Window( 2, 4, 78, N_Nos + 3 );
  1292.  
  1293.                                    (* Remove highlight from top line *)
  1294.  
  1295.                            GoToXY( 1 , 1 );
  1296.  
  1297.                            WITH Phone_Entries[1] DO
  1298.                               WRITELN( Low_Num:3, '  ',     Phone_Name:25,
  1299.                                                   '  ',     Phone_Number:15,
  1300.                                                   '   ',    Phone_Baud:5,
  1301.                                                   '    ',   Phone_DataBits:1,
  1302.                                                   '      ', Phone_Parity:1,
  1303.                                                   '     ',  Phone_StopBits:1 );
  1304.  
  1305.                                    (* Make room for new line *)
  1306.  
  1307.                            GoToXY( 1 , 1 );
  1308.                            InsLine;
  1309.  
  1310.                            Low_Num  := Low_Num  - 1;
  1311.                            Hi_Num   := Hi_Num   - 1;
  1312.  
  1313.                                    (* Move current entries up *)
  1314.  
  1315.                            MOVE( Phone_Entries[1], Phone_Entries[2],
  1316.                                  ( N_Nos - 1 ) * SizeOf( Phone_Entries[1] ) );
  1317.  
  1318.                                    (* Get data for new line *)
  1319.  
  1320.                               (*$I-*)
  1321.                            SEEK( Phone_File , Low_Num - 1 );
  1322.                               (*$I+*)
  1323.                            IF Int24Result = 0 THEN
  1324.                               READ( Phone_File , Phone_Entries[ 1 ] );
  1325.  
  1326.                                    (* Draw new line *)
  1327.  
  1328.                            RvsVideoOn( ForeGround_Color , BackGround_Color );
  1329.  
  1330.                            WITH Phone_Entries[1] DO
  1331.                               WRITELN( Low_Num:3, '  ',     Phone_Name:25,
  1332.                                                   '  ',     Phone_Number:15,
  1333.                                                   '   ',    Phone_Baud:5,
  1334.                                                   '    ',   Phone_DataBits:1,
  1335.                                                   '      ', Phone_Parity:1,
  1336.                                                   '     ',  Phone_StopBits:1 );
  1337.                            Window( 2, 4, 78, 24 );
  1338.  
  1339.                            RvsVideoOff( ForeGround_Color , BackGround_Color );
  1340.  
  1341.                         END;
  1342.  
  1343.                   END   (* Scroll up one line *);
  1344.  
  1345.          'D':     BEGIN (* Scroll down one line *)
  1346.  
  1347.                      Redraw := FALSE;
  1348.  
  1349.                      IF Low_Num < Default_Phone_Number_Size THEN
  1350.                         BEGIN
  1351.                                    (* Make room for new line *)
  1352.  
  1353.                            Window( 2, 4, 78, N_Nos + 4 );
  1354.  
  1355.                            GoToXY( 1 , 1 );
  1356.                            DelLine;
  1357.  
  1358.                            Low_Num := Low_Num + 1;
  1359.                            Hi_Num  := MIN( Low_Num + N_Nos - 1 ,
  1360.                                            Default_Phone_Number_Size );
  1361.                            J        := Hi_Num - Low_Num + 1;
  1362.  
  1363.                                    (* Move current entries down *)
  1364.  
  1365.                            MOVE( Phone_Entries[2], Phone_Entries[1],
  1366.                                  ( J - 1 ) * SizeOf( Phone_Entries[1] ) );
  1367.  
  1368.                               (*$I-*)
  1369.                            SEEK( Phone_File , Hi_Num - 1 );
  1370.                               (*$I+*)
  1371.                            IF Int24Result = 0 THEN
  1372.                               READ( Phone_File , Phone_Entries[ J ] );
  1373.  
  1374.                            GoToXY( 1 , J );
  1375.  
  1376.                            WITH Phone_Entries[ J ] DO
  1377.                               WRITELN( Hi_Num:3, '  ',     Phone_Name:25,
  1378.                                                  '  ',     Phone_Number:15,
  1379.                                                  '   ',    Phone_Baud:5,
  1380.                                                  '    ',   Phone_DataBits:1,
  1381.                                                  '      ', Phone_Parity:1,
  1382.                                                  '     ',  Phone_StopBits:1 );
  1383.  
  1384.                            RvsVideoOn( ForeGround_Color , BackGround_Color );
  1385.  
  1386.                            GoToXY( 1 , 1 );
  1387.  
  1388.                            WITH Phone_Entries[ 1 ] DO
  1389.                               WRITELN( Low_Num:3, '  ',     Phone_Name:25,
  1390.                                                   '  ',     Phone_Number:15,
  1391.                                                   '   ',    Phone_Baud:5,
  1392.                                                   '    ',   Phone_DataBits:1,
  1393.                                                   '      ', Phone_Parity:1,
  1394.                                                   '     ',  Phone_StopBits:1 );
  1395.  
  1396.                            RvsVideoOff( ForeGround_Color , BackGround_Color );
  1397.  
  1398.                            Window( 2, 4, 78, 23 );
  1399.  
  1400.                         END
  1401.                      ELSE
  1402.                         Menu_Beep;
  1403.  
  1404.                   END   (* Scroll down one line *);
  1405.  
  1406.                                    (* Entry to dial *)
  1407.  
  1408.          '0'..'9', '+','-','!','@','#':
  1409.  
  1410.                   IF ( NOT Dialer_Carrier_Detect ) THEN
  1411.                      Extract_Dialing_Entry( -1 )
  1412.                   ELSE
  1413.                      BEGIN
  1414.                         Save_Screen( Local_Save_3 );
  1415.                         Window( 1, 1, 80, 25 );
  1416.                         Draw_Menu_Frame( 10, 10, 60, 14, Menu_Frame_Color,
  1417.                                          Menu_Text_Color + Blink, '' );
  1418.                         WRITELN('Session already in progress.');
  1419.                         WRITE  ('Dialing request ignored.');
  1420.                         DELAY( Two_Second_Delay );
  1421.                         Restore_Screen( Local_Save_3 );
  1422.                         TextColor( Menu_Text_Color );
  1423.                         ReDraw    := FALSE;
  1424.                      END;
  1425.                                    (* Revise/add a dialing entry *)
  1426.  
  1427.          'R':     Revise_Phone_Entry;
  1428.  
  1429.                                    (* Revise dialing prefix/postfix *)
  1430.  
  1431.          'P':     BEGIN
  1432.                      Revise_Dialing_Prefix;
  1433.                      Redraw := FALSE;
  1434.                   END;
  1435.                                    (* Start a redial             *)
  1436.  
  1437.          'Q':     BEGIN
  1438.                      IF Phone_Number = '' THEN
  1439.                         Extract_Dialing_Entry( Low_Num );
  1440.                      Done   := TRUE;
  1441.                      ReDial := TRUE;
  1442.                   END;
  1443.  
  1444.                                    (* Ignore extraneous backspace *)
  1445.          ^H:      BEGIN
  1446.                      Redraw := FALSE;
  1447.                   END;
  1448.  
  1449.                                    (* Hang up the phone *)
  1450.          'H':     BEGIN
  1451.  
  1452.                      Redraw := FALSE;
  1453.  
  1454.                      Save_Screen( Local_Save_2 );
  1455.  
  1456.                      Draw_Menu_Frame( 10, 10, 60, 15, Menu_Frame_Color,
  1457.                                       Menu_Text_Color, '' );
  1458.  
  1459.                      WRITELN;
  1460.                      WRITELN('*** Hanging up the phone ***');
  1461.  
  1462.                                    (* Hang up the phone *)
  1463.  
  1464.                      HangUpPhone;
  1465.  
  1466.                      IF Async_Carrier_Detect THEN
  1467.                         WRITELN('*** Phone not hung up, try again ***')
  1468.                      ELSE
  1469.                         BEGIN
  1470.                            WRITELN('*** Phone hung up ***');
  1471.                            Qerr := Async_Open( Comm_Port, Baud_Rate,
  1472.                                                Parity, Data_Bits,
  1473.                                                Stop_Bits );
  1474.                         END;
  1475.  
  1476.                      DELAY( Two_Second_Delay );
  1477.  
  1478.                      Restore_Screen( Local_Save_2 );
  1479.                      TextColor( Menu_Text_Color );
  1480.  
  1481.                   END;
  1482.  
  1483.                                    (* Dial top number on screen *)
  1484.          ^M,
  1485.          ' ':     IF ( NOT Dialer_Carrier_Detect ) THEN
  1486.                      Extract_Dialing_Entry( Low_Num )
  1487.                   ELSE
  1488.                      BEGIN
  1489.                         Save_Screen( Local_Save_3 );
  1490.                         Window( 1, 1, 80, 25 );
  1491.                         Draw_Menu_Frame( 10, 10, 60, 14, Menu_Frame_Color,
  1492.                                          Menu_Text_Color + Blink, '' );
  1493.                         WRITELN('Session already in progress.');
  1494.                         WRITE  ('Dialing request ignored.');
  1495.                         DELAY( Two_Second_Delay );
  1496.                         Restore_Screen( Local_Save_3 );
  1497.                         TextColor( Menu_Text_Color );
  1498.                         ReDraw    := FALSE;
  1499.                      END;
  1500.  
  1501.                                    (* Manual dial *)
  1502.          'M':     BEGIN
  1503.                      Done   := Do_Manual_Dial;
  1504.                      ReDraw := FALSE;
  1505.                   END;
  1506.  
  1507.                                    (* 'L' -- list of numbers given *)
  1508.          'L':     BEGIN
  1509.                      Save_Screen( Local_Save_3 );
  1510.                      Window( 1, 1, 80, 25 );
  1511.                      Draw_Menu_Frame( 10, 10, 60, 22, Menu_Frame_Color,
  1512.                                       Menu_Text_Color, 'Numbers to Dial' );
  1513.                      Get_List_Of_Phone_Numbers;
  1514.                      Restore_Screen( Local_Save_3 );
  1515.                      TextColor( Menu_Text_Color );
  1516.                      ReDraw := FALSE;
  1517.                      Done   := ( N_Dial_Nos > 0 );
  1518.                   END;
  1519.                                    (* Beep on anything else -- bad *)
  1520.          ELSE
  1521.             Menu_Beep;
  1522.             ReDraw := FALSE;
  1523.  
  1524.       END (* CASE *);
  1525.  
  1526.    UNTIL Done;
  1527.                                    (* Remember current dialing page *)
  1528.    Phone_Entry_Page := Low_Num;
  1529.                                    (* Restore dialing box *)
  1530.    Restore_Screen( Local_Save );
  1531.    Reset_Global_Colors;
  1532.  
  1533. END   (* Display_Phone_Numbers *);
  1534.